package com.demo.xj_plane.common.utils;

import org.apache.commons.lang3.StringUtils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
import java.util.Calendar;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * 时间工具类
 */
public class DateUtil {

    final static public String HH_DATA_FORMAT = "yyyyMMdd";

    final static public String DATA_FORMAT = "yyyyMMddHH";

    final static public String FULL_ST_FORMAT = "yyyyMMddHHmmss";

    final static public String FULL_STANDARD_FORMAT = "yyyy-MM-dd HH:mm:ss";

    final static public String FULL_STANDARD_FORMAT_HH = "yyyy-MM-dd HH:mm";

    final static public String NC_ST_FORMAT = "yyyy-MM-dd_HH:mm:ss";

    final static public String NC_ST_FORMAT_HH = "MM月dd日HH时";

    /**
     * 获取传入的两个时间之间的时间差，结果可选择为差距的天数，小时数或者分钟数
     * @param type  1天数 2小时数 3分钟数
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @param timeFormat "1" yyyyMMddHHmmss "2" yyyy-MM-dd HH:mm:ss
     * @return
     */
    public static int getTimesDiff(int type, String startTime, String endTime, String timeFormat) {
        Map<String, String> timeFormatMap = new HashMap<>();
        // 不同的时间类型
        timeFormatMap.put("1",FULL_ST_FORMAT);// yyyyMMddHHmmss
        timeFormatMap.put("2",FULL_STANDARD_FORMAT);// yyyy-MM-dd HH:mm:ss
        if (StringUtils.isNotBlank(startTime) && StringUtils.isNotBlank(endTime)) {
            try {
                // 使用SimpleDateFormat类进行时间计算
                SimpleDateFormat sdf = new SimpleDateFormat(timeFormatMap.get(timeFormat));
                long from = sdf.parse(startTime).getTime();
                long to = sdf.parse(endTime).getTime();
                int times = 0;
                // 根据需求，将结果转换天，小时，分钟返回
                if (type == 1) {
                    times = (int) ((to - from) / (1000 * 60 * 60 * 24));
                } else if (type == 2) {
                    times = (int) ((to - from) / (1000 * 60 * 60));
                } else if (type == 3) {
                    times = (int) ((to - from) / (1000 * 60));
                }
                return times;
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 计算传入的两个时间的时间差（分+秒），返回结果为，x分x秒，连带着
     * @param startTime 开始时间
     * @param endTime 结束时间
     * @return
     */
    public static String getTimesDiff1(String startTime, String endTime) {
        if (StringUtils.isNotBlank(startTime) && StringUtils.isNotBlank(endTime)) {
            try {
                // 将类型转换为"yyyy-MM-dd HH:mm:ss"，进行计算
                SimpleDateFormat sdf = new SimpleDateFormat(FULL_STANDARD_FORMAT);// FULL_STANDARD_FORMAT
                long from = sdf.parse(startTime).getTime();
                long to = sdf.parse(endTime).getTime();
                String times = "";
                // 计算时间差，分+秒
                int timesFen = (int) ((to - from) / (1000 * 60));
                int timesMiao = (int) (((to - from) % (1000 * 60)) / 1000);
                times = timesFen + "分" + timesMiao + "秒";
                return times;
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return "";
    }

    /**
     * 取传入的两个时间之间的时间差，结果可选择为差距的天数，小时数，分钟数以及秒数
     *
     * @param type      1天数 2小时数 3分钟数 4秒数
     * @param startTime
     * @param endTime
     * @return
     */
    public static int getTimesDiff2(int type, String startTime, String endTime, String timeType) {
        Map<String, String> timeFormatMap = new HashMap<>();
        // 不同的时间类型
        timeFormatMap.put("1",FULL_ST_FORMAT);// yyyyMMddHHmmss
        timeFormatMap.put("2",FULL_STANDARD_FORMAT);// yyyy-MM-dd HH:mm:ss
        timeFormatMap.put("3",DATA_FORMAT);// yyyyMMddHH
        if (StringUtils.isNotBlank(startTime) && StringUtils.isNotBlank(endTime)) {
            try {
                // 使用SimpleDateFormat类进行时间计算
                SimpleDateFormat sdf = new SimpleDateFormat(timeFormatMap.get(timeType));
                long from = sdf.parse(startTime).getTime();
                long to = sdf.parse(endTime).getTime();
                int times = 0;
                // 根据需求，将结果转换天，小时，分钟，秒数返回
                if (type == 1) {
                    times = (int) ((to - from) / (1000 * 60 * 60 * 24));
                } else if (type == 2) {
                    times = (int) ((to - from) / (1000 * 60 * 60));
                } else if (type == 3) {
                    times = (int) ((to - from) / (1000 * 60));
                } else if (type == 4) {
                    times = (int) ((to - from) / (1000));
                }
                return times;
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
        return -1;
    }

    /**
     * 将传入的时间，转换为模式用的时次的类型
     * 如：2023-07-26 10:55:36格式转换为2023072610
     * @param date
     * @return
     */
    public static String timeConversionStdt(String date) {
        // 使用DateTimeFormatter解析传入的日期字符串为LocalDateTime对象
        LocalDateTime dateTime = LocalDateTime.parse(date, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        // 使用DateTimeFormatter将LocalDateTime对象格式化为"yyyyMMddHH"的字符串
        String formattedBeginTime = dateTime.format(DateTimeFormatter.ofPattern("yyyyMMddHH"));
        // 返回需要的时次
        return formattedBeginTime;
    }


    /**
     * 将日期字符串从一种格式转换为另一种格式
     * 转换格式方法1
     * 将yyyyMMddHHmmss格式转换为2023-07-26 10:55:36
     * @param date
     * @return
     */
    public static String timeConversion2(String date) {
        // 同上
        LocalDateTime dateTime = LocalDateTime.parse(date, DateTimeFormatter.ofPattern("yyyyMMddHHmmss"));
        String formattedDateTime = dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
        return formattedDateTime;
    }

    /**
     * 获取上一天时间时次：
     * 用于模式失败，大屏显示上一天内容，获取上一天时次
     * @return
     */
    public static String getPastCurStdt(){
        // 获取当前日期
        LocalDate currentDate = LocalDate.now();
        // 计算前一天的日期
        LocalDate previousDay = currentDate.minusDays(1);
        // 格式化前一天的日期为字符串，格式为yyyyMMdd
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMdd");
        String formattedDate = previousDay.format(formatter);
        return formattedDate;
    }

    /**
     * 获取当前时间，北京时
     *
     */
    public static String getCurrentTime() {
        // 获取当前时间
        LocalDateTime now = LocalDateTime.now();
        // 格式化时间为yyyyMMddHHmm
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
        String formattedTime = now.format(formatter);
        return formattedTime;
    }

    /**
     * 获取当前时间，世界时
     *
     * @return
     */
    public static String getCurrentTimeUtc() {
        // 获取当前时间，世界时
        LocalDateTime currentTime = LocalDateTime.now(ZoneOffset.UTC);
        // 转换为dt
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
        String utcTime = currentTime.format(formatter);
        return utcTime;
    }

    /**
     * 获取当前时间，世界时，前半小时
     *
     * @return
     */
    public static String getCurrentTimeUtcAgo() {
        // 获取当前时间，世界时
        LocalDateTime currentTime = LocalDateTime.now(ZoneOffset.UTC);
        // 计算前一天的日期
        LocalDateTime localDateTime = currentTime.minusMinutes(30);
        // 转换为dt
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyyMMddHHmmss");
        String utcTime = localDateTime.format(formatter);
        return utcTime;
    }

    public static void main(String[] args) {
        String currentTimeUtcAgo = getCurrentTimeUtcAgo();
        System.out.println(currentTimeUtcAgo);
    }
}